@kernel.chat/kbot 3.97.0 → 3.97.4

package/README.md

@@ -2,11 +2,11 @@
 
 <p align="center">
   <strong>kbot</strong><br>
-  Open-source terminal AI agent. 764+ tools. 35 agents. 20 providers. Dreams, learns, watches your system, controls your phone. $0 local.
+  Open-source terminal AI agent. 787+ tools. 35 agents. 20 providers. Dreams, learns, watches your system, controls your phone. $0 local.
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo.gif" alt="kbot demo" width="700">
+  <img src="https://raw.githubusercontent.com/isaacsight/kernel/main/tools/video-assets/demo-quick.gif" alt="kbot demo" width="700">
 </p>
 
 <p align="center">
@@ -31,7 +31,7 @@ Most terminal AI agents lock you into one provider, one model, one way of workin
 - **Runs fully offline** — Embedded llama.cpp, Ollama, LM Studio, or Jan. $0, fully private.
 - **Learns your patterns** — Bayesian skill ratings + pattern extraction. Gets faster over time.
 - **35 specialist agents** — auto-routes your request to the right expert (coder, researcher, writer, guardian, quant, and 30 more).
-- **764+ tools** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, music production, iPhone control, and more.
+- **787+ tools** — files, bash, git, GitHub, web search, deploy, database, game dev, VFX, research, science, finance, security, music production, iPhone control, and more.
 - **Programmatic SDK** — use kbot as a library in your own apps.
 - **MCP server built in** — plug kbot into Claude Code, Cursor, VS Code, Zed, or Neovim as a tool provider.
 
@@ -142,7 +142,7 @@ Checks security, documentation, code quality, CI/CD, community health, and DevOp
 |---|---|---|---|---|---|
 | AI providers | 20 | 1 | 1 | 6 | 75+ |
 | Specialist agents | 35 | 0 | 0 | 0 | 0 |
-| Built-in tools | 764+ | ~20 | ~15 | ~10 | ~15 |
+| Built-in tools | 787+ | ~20 | ~15 | ~10 | ~15 |
 | Science tools | 114 | 0 | 0 | 0 | 0 |
 | Memory system | 7-tier bidirectional | File-based | No | No | No |
 | Dream engine | Yes ($0 local) | Cloud API | No | No | No |

package/dist/cli.js

@@ -102,7 +102,7 @@ async function main() {
         console.log(`  ${chalk.cyan('https://github.com/isaacsight/kernel/issues')}  ${chalk.dim('Bug reports')}`);
         console.log(`  ${chalk.cyan('support@kernel.chat')}  ${chalk.dim('Email (AI-assisted replies)')}`);
         console.log();
-        console.log(`  ${chalk.dim('35 specialist agents · 360+ tools · 20 providers · MIT licensed')}`);
+        console.log(`  ${chalk.dim('35 specialist agents · 787+ tools · 20 providers · MIT licensed')}`);
         console.log();
         process.exit(0);
     });

package/dist/coordinator.d.ts

@@ -129,4 +129,36 @@ export declare class IntelligenceCoordinator {
 export declare function getCoordinator(): IntelligenceCoordinator;
 /** Register coordinator tools with the kbot tool registry */
 export declare function registerCoordinatorTools(): void;
+export interface Task {
+    id: string;
+    goal: string;
+    status: 'pending' | 'running' | 'done' | 'failed';
+    agent: string;
+    dependencies: string[];
+    result?: string;
+    error?: string;
+}
+export interface CoordinatorPlan {
+    id: string;
+    goal: string;
+    tasks: Task[];
+    createdAt: string;
+    completedAt?: string;
+    status: 'planning' | 'executing' | 'done' | 'failed';
+}
+/**
+ * Decompose a high-level goal into ordered sub-tasks with dependencies.
+ * Uses the LLM (via runAgent) to break the goal into 2-6 concrete tasks.
+ */
+export declare function decompose(goal: string): Promise<CoordinatorPlan>;
+/**
+ * Execute a plan's tasks in dependency order (sequential for now).
+ * Tasks whose dependencies are all 'done' are eligible to run.
+ */
+export declare function execute(plan: CoordinatorPlan): Promise<CoordinatorPlan>;
+/**
+ * Convenience: decompose a goal, execute the plan, and synthesize results.
+ * Returns a human-readable summary of what was accomplished.
+ */
+export declare function coordinate(goal: string): Promise<string>;
 //# sourceMappingURL=coordinator.d.ts.map

package/dist/coordinator.js

@@ -8,6 +8,7 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import chalk from 'chalk';
 // ── Lazy module loaders (dynamic imports to break circular deps) ──
 async function getLearning() { return import('./learning.js'); }
 async function getConfidence() { return import('./confidence.js'); }
@@ -673,10 +674,166 @@ export function registerCoordinatorTools() {
                 return JSON.stringify(result, null, 2);
             },
         });
+        registerTool({
+            name: 'coordinator_orchestrate',
+            description: 'Decompose a goal into sub-tasks, assign specialist agents, execute in dependency order, and synthesize results',
+            parameters: { goal: { type: 'string', description: 'The high-level goal to orchestrate', required: true } },
+            tier: 'free',
+            execute: async (args) => coordinate(args.goal),
+        });
     }).catch(() => {
         // tools/index.js not available — skip registration
     });
 }
+// ── Goal Decomposition & Multi-Agent Orchestration ──
+//
+// Takes a high-level goal and:
+// 1. Decomposes it into ordered sub-tasks via LLM
+// 2. Assigns each sub-task to the best specialist agent
+// 3. Manages dependencies between sub-tasks
+// 4. Synthesizes results into a final output
+// 5. Learns from the execution for next time
+const COORD_AMETHYST = typeof chalk.hex === 'function' ? chalk.hex('#6B5B95') : ((s) => s);
+const DECOMPOSE_PROMPT = `You are a task decomposition engine. Break the goal into 2-6 concrete sub-tasks.
+Output ONLY valid JSON: {"tasks":[{"id":"t1","goal":"...","agent":"agent_id","dependencies":[]}]}
+Agents: kernel (general), coder (code/debug), researcher (research), writer (docs), analyst (strategy), guardian (security), infrastructure (devops).
+Rules: each task independently verifiable, use dependencies for ordering, assign best agent, one objective per task.`;
+/**
+ * Decompose a high-level goal into ordered sub-tasks with dependencies.
+ * Uses the LLM (via runAgent) to break the goal into 2-6 concrete tasks.
+ */
+export async function decompose(goal) {
+    const planId = shortId();
+    const plan = {
+        id: planId,
+        goal,
+        tasks: [],
+        createdAt: new Date().toISOString(),
+        status: 'planning',
+    };
+    process.stderr.write(`  ${COORD_AMETHYST('◆ decompose')} ${chalk.dim(goal.slice(0, 80))}${goal.length > 80 ? '...' : ''}\n`);
+    try {
+        // Lazy import to avoid circular dependency
+        const { runAgent } = await import('./agent.js');
+        const response = await runAgent(`${DECOMPOSE_PROMPT}\n\nGoal: ${goal}\n\nOutput JSON:`, { agent: 'kernel', skipPlanner: true, sessionId: `coord-${planId}` });
+        // Parse JSON from response
+        const jsonMatch = response.content.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+            const parsed = JSON.parse(jsonMatch[0]);
+            plan.tasks = (parsed.tasks || []).slice(0, 6).map(t => ({
+                id: t.id || shortId(),
+                goal: t.goal,
+                status: 'pending',
+                agent: t.agent || 'kernel',
+                dependencies: t.dependencies || [],
+            }));
+        }
+    }
+    catch (err) {
+        process.stderr.write(`  ${chalk.red('✗')} decomposition failed: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    // Fallback: if decomposition produced nothing, create a single task
+    if (plan.tasks.length === 0) {
+        plan.tasks = [{
+                id: 't1',
+                goal,
+                status: 'pending',
+                agent: 'kernel',
+                dependencies: [],
+            }];
+    }
+    plan.status = 'executing';
+    for (const task of plan.tasks) {
+        const deps = task.dependencies.length > 0 ? chalk.dim(` -> ${task.dependencies.join(',')}`) : '';
+        process.stderr.write(`  ${chalk.dim('│')} ${chalk.cyan(task.id)} ${task.goal} ${chalk.magenta(`@${task.agent}`)}${deps}\n`);
+    }
+    return plan;
+}
+/**
+ * Execute a plan's tasks in dependency order (sequential for now).
+ * Tasks whose dependencies are all 'done' are eligible to run.
+ */
+export async function execute(plan) {
+    const { runAgent } = await import('./agent.js');
+    const completed = new Set();
+    process.stderr.write(`\n  ${COORD_AMETHYST('◆ execute')} ${plan.tasks.length} tasks\n`);
+    while (completed.size < plan.tasks.length) {
+        // Find tasks whose dependencies are all satisfied
+        const ready = plan.tasks.filter(t => t.status === 'pending' &&
+            t.dependencies.every(dep => completed.has(dep)));
+        if (ready.length === 0) {
+            // Remaining tasks have unmet deps — mark them failed
+            for (const t of plan.tasks) {
+                if (t.status === 'pending') {
+                    t.status = 'failed';
+                    t.error = 'Unmet dependencies (earlier tasks failed)';
+                    completed.add(t.id);
+                }
+            }
+            break;
+        }
+        // Execute ready tasks sequentially (parallel execution can come later)
+        for (const task of ready) {
+            task.status = 'running';
+            process.stderr.write(`  ${chalk.dim('├')} ${chalk.yellow('●')} ${task.id}: ${task.goal}\n`);
+            // Gather dependency results as context
+            const depCtx = task.dependencies
+                .map(id => { const d = plan.tasks.find(t => t.id === id); return d?.result ? `[${id}]: ${d.result.slice(0, 500)}` : ''; })
+                .filter(Boolean).join('\n');
+            const prompt = `You are executing a sub-task of a larger plan.${depCtx ? `\n\nPrevious results:\n${depCtx}` : ''}\n\nYour task: ${task.goal}\n\nExecute this now.`;
+            try {
+                const response = await runAgent(prompt, {
+                    agent: task.agent,
+                    skipPlanner: true,
+                    sessionId: `coord-${plan.id}-${task.id}`,
+                });
+                task.result = response.content;
+                task.status = 'done';
+                process.stderr.write(`  ${chalk.dim('│')} ${chalk.green('✓')} ${task.id} done\n`);
+            }
+            catch (err) {
+                task.status = 'failed';
+                task.error = err instanceof Error ? err.message : String(err);
+                process.stderr.write(`  ${chalk.dim('│')} ${chalk.red('✗')} ${task.id} failed: ${task.error}\n`);
+            }
+            completed.add(task.id);
+        }
+    }
+    // Determine final plan status
+    const failed = plan.tasks.filter(t => t.status === 'failed');
+    plan.status = failed.length === 0 ? 'done' : 'failed';
+    plan.completedAt = new Date().toISOString();
+    const done = plan.tasks.filter(t => t.status === 'done').length;
+    process.stderr.write(`  ${chalk.dim('└')} ${done}/${plan.tasks.length} tasks succeeded\n`);
+    // Record outcome for learning
+    try {
+        const coord = getCoordinator();
+        if (plan.status === 'done')
+            coord.addGoal(plan.goal, 0.7).status = 'completed';
+        const learning = await getLearning();
+        learning.learnFromExchange(`[coordinator] ${plan.goal}`, `${done}/${plan.tasks.length} done`, plan.tasks.map(t => t.agent));
+    }
+    catch { /* non-critical */ }
+    return plan;
+}
+/**
+ * Convenience: decompose a goal, execute the plan, and synthesize results.
+ * Returns a human-readable summary of what was accomplished.
+ */
+export async function coordinate(goal) {
+    const plan = await decompose(goal);
+    const executed = await execute(plan);
+    // Synthesize results
+    const results = executed.tasks
+        .filter(t => t.status === 'done' && t.result)
+        .map(t => `## ${t.goal}\n${t.result}`)
+        .join('\n\n');
+    const failed = executed.tasks.filter(t => t.status === 'failed');
+    const failSummary = failed.length > 0
+        ? `\n\n---\n${failed.length} task(s) failed:\n${failed.map(t => `- ${t.goal}: ${t.error}`).join('\n')}`
+        : '';
+    return results + failSummary;
+}
 // Auto-register tools when this module is imported
 registerCoordinatorTools();
 //# sourceMappingURL=coordinator.js.map

package/dist/doctor.js

@@ -518,11 +518,12 @@ export async function runDoctor() {
 // ── Formatter ──
 // Color palette matching ui.ts
 const useColor = !process.env.NO_COLOR && process.stdout.isTTY !== false;
-const GREEN = useColor ? chalk.hex('#4ADE80') : chalk;
-const RED = useColor ? chalk.hex('#F87171') : chalk;
-const YELLOW = useColor ? chalk.hex('#FBBF24') : chalk;
+const hex = typeof chalk.hex === 'function' ? (c) => chalk.hex(c) : () => ((s) => s);
+const GREEN = useColor ? hex('#4ADE80') : ((s) => s);
+const RED = useColor ? hex('#F87171') : ((s) => s);
+const YELLOW = useColor ? hex('#FBBF24') : ((s) => s);
 const DIM = useColor ? chalk.dim : ((s) => s);
-const ACCENT = useColor ? chalk.hex('#A78BFA') : chalk;
+const ACCENT = useColor ? hex('#A78BFA') : ((s) => s);
 const STATUS_ICON = {
     pass: GREEN('✓'),
     warn: YELLOW('!'),

package/dist/share.js

@@ -25,7 +25,7 @@ export function formatShareMarkdown(turns, meta) {
     const lines = [
         `# ${name}`,
         '',
-        `> Generated with [kbot](${KBOT_URL}) — 25 specialist agents, 290+ tools, 20 AI providers`,
+        `> Generated with [kbot](${KBOT_URL}) — 35 specialist agents, 787+ tools, 20 AI providers`,
         `> Agent: \`${agent}\` | Date: ${date}`,
         '',
         '---',

package/dist/streaming.js

@@ -7,7 +7,7 @@
 // The thinking display shows the AI's reasoning process in real-time,
 // then the final response renders normally.
 import chalk from 'chalk';
-const ACCENT_DIM = chalk.hex('#7C6CB0');
+const ACCENT_DIM = typeof chalk.hex === 'function' ? chalk.hex('#7C6CB0') : chalk.dim;
 const THINKING_COLOR = chalk.dim.italic;
 /** Max accumulated content size during streaming (5MB) to prevent OOM */
 const MAX_STREAM_CONTENT = 5 * 1024 * 1024;

package/dist/tools/ableton.js

@@ -11,10 +11,12 @@
 //   ableton_mixer           — snapshot levels, batch set, sends
 //   ableton_create_progression — chord progressions → MIDI in clips
 //   ableton_session_info    — full session state snapshot
+//   ableton_audio_analysis  — real-time audio level meters (track + master RMS)
 //   ableton_knowledge       — deep Ableton knowledge base queries (registered in ableton-knowledge.ts)
 //
 // Requires: AbletonOSC loaded in Ableton Live (Preferences → Link/Tempo/MIDI → Control Surface)
 import { registerTool } from './index.js';
+import { execSync } from 'node:child_process';
 import { ensureAbleton, formatAbletonError } from '../integrations/ableton-osc.js';
 import { parseProgression, voiceChord, arpeggiate, NAMED_PROGRESSIONS, RHYTHM_PATTERNS, GENRE_DRUM_PATTERNS, noteNameToMidi, midiToNoteName, } from './music-theory.js';
 // ── Helpers ─────────────────────────────────────────────────────────────────
@@ -769,52 +771,89 @@ export function registerAbletonTools() {
     // ─── 10. Load Plugin ──────────────────────────────────────────────────
     registerTool({
         name: 'ableton_load_plugin',
-        description: 'Load any instrument or plugin onto a track by name — native (Operator, Wavetable, Drift) or third-party VST/AU (Serum 2, Vital, Kontakt). Searches Ableton\'s browser and loads onto the selected track.',
+        description: 'Load any instrument or plugin onto a track by name — native (Operator, Wavetable, Drift) or third-party VST/AU (Serum 2, Vital, Kontakt). Tries OSC first, then falls back to AppleScript browser automation on macOS.',
         parameters: {
             track: { type: 'number', description: 'Track number (1-based)', required: true },
             plugin: { type: 'string', description: 'Plugin name to search for (e.g. "Serum 2", "Operator", "Wavetable")', required: true },
             manufacturer: { type: 'string', description: 'Manufacturer name for VST/AU (e.g. "Xfer Records", "Native Instruments"). Optional — helps narrow search.' },
+            skip_results: { type: 'number', description: 'Number of Down arrow presses before selecting (to skip past FX/presets). Default: 1' },
         },
         tier: 'free',
-        timeout: 15_000,
+        timeout: 20_000,
         async execute(args) {
             const t = userTrack(args.track);
             const plugin = String(args.plugin);
             const manufacturer = args.manufacturer ? String(args.manufacturer) : '';
+            const skipResults = Number(args.skip_results) || 1;
+            // ── Attempt 1: OSC (fast, reliable for native instruments) ──
             try {
                 const osc = await ensureAbleton();
-                if (manufacturer) {
-                    const result = await osc.query('/live/kbot/load_plugin', t, manufacturer, plugin);
-                    const status = extractArgs(result);
-                    if (status[0] === 'ok') {
-                        return `Loaded **${status[1]}** on track ${args.track}`;
-                    }
-                    return `Could not find "${manufacturer} ${plugin}": ${status.join(', ')}`;
-                }
-                // Try load_plugin first — _deep_plugin_search correctly handles native
-                // instruments by returning the first loadable child of matching browser folders.
-                // This works for both native (Drum Rack, Operator, Wavetable) and third-party plugins.
-                let result = await osc.query('/live/kbot/load_plugin', t, plugin, '');
-                let status = extractArgs(result);
-                if (status[0] === 'ok') {
-                    return `Loaded **${status[1]}** on track ${args.track}`;
-                }
-                // Fallback: try load_device (uses _search_tree, less reliable for native instruments)
-                result = await osc.query('/live/kbot/load_device', t, plugin);
-                status = extractArgs(result);
-                if (status[0] === 'ok') {
-                    return `Loaded **${status[1]}** on track ${args.track}`;
+                // Select the target track first so the plugin loads there
+                osc.send('/live/song/set/current_track', t);
+                await new Promise(r => setTimeout(r, 200));
+                // Try native load_device endpoint (works for Ableton built-in instruments)
+                const nativeResult = await osc.query('/live/track/load/device', t, plugin);
+                const nativeStatus = extractArgs(nativeResult);
+                if (nativeStatus.length > 0 && String(nativeStatus[0]) !== 'error') {
+                    return `Loaded **${plugin}** on track ${args.track} (via OSC)`;
                 }
-                // Final fallback: try plugins category with name as both manufacturer and plugin
-                result = await osc.query('/live/kbot/load_plugin', t, plugin, plugin);
-                status = extractArgs(result);
-                if (status[0] === 'ok') {
-                    return `Loaded **${status[1]}** on track ${args.track}`;
+            }
+            catch {
+                // OSC failed — fall through to AppleScript
+            }
+            // ── Attempt 2: AppleScript browser automation (macOS only) ──
+            // Uses Ableton's built-in browser search: Cmd+F → type name → arrow down → Return
+            // Proven approach from ZENOLOGY loading session
+            if (process.platform !== 'darwin') {
+                return `Plugin "${plugin}" could not be loaded via OSC. AppleScript fallback is macOS-only.`;
+            }
+            try {
+                const searchTerm = manufacturer ? `${manufacturer} ${plugin}` : plugin;
+                // Build AppleScript: activate Ableton, open browser search, type plugin name, select, load
+                const downArrows = Array(skipResults).fill('key code 125').join('\ndelay 0.3\n'); // 125 = Down arrow
+                const script = `
+tell application "Ableton Live 12"
+  activate
+end tell
+delay 0.5
+tell application "System Events"
+  tell process "Ableton Live 12"
+    -- Open browser search: Cmd+F (View > Search in Browser)
+    keystroke "f" using command down
+    delay 0.8
+    -- Clear any existing search text and type plugin name
+    keystroke "a" using command down
+    delay 0.1
+    keystroke "${searchTerm.replace(/"/g, '\\"')}"
+    delay 1.0
+    -- Navigate down to the result (skip past categories/folders)
+    ${downArrows}
+    delay 0.3
+    -- Press Return to load the selected item onto the current track
+    key code 36
+    delay 0.5
+  end tell
+end tell
+return "ok"
+`;
+                const lines = script.split('\n').filter(l => l.trim());
+                const escapedArgs = lines.map(l => `-e '${l.replace(/'/g, "'\\''")}'`).join(' ');
+                const result = execSync(`osascript ${escapedArgs}`, {
+                    encoding: 'utf-8',
+                    timeout: 15_000,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                }).trim();
+                if (result === 'ok') {
+                    return `Loaded **${plugin}** on track ${args.track} (via AppleScript browser search)`;
                 }
-                return `Plugin "${plugin}" not found in Ableton's browser. Check the name and try again.`;
+                return `AppleScript returned unexpected result: ${result}`;
             }
             catch (err) {
-                return `Ableton connection failed: ${err.message}\n\n${formatAbletonError()}`;
+                const msg = err.message;
+                if (msg.includes('not allowed') || msg.includes('assistive')) {
+                    return `AppleScript failed — Accessibility permission required.\n\nGrant permission in System Settings > Privacy & Security > Accessibility for your terminal app.`;
+                }
+                return `Failed to load "${plugin}": OSC endpoint not available, AppleScript fallback failed.\n\nError: ${msg}`;
             }
         },
     });
@@ -964,21 +1003,19 @@ export function registerAbletonTools() {
                 if (args.name) {
                     osc.send('/live/track/set/name', newTrackIdx, String(args.name));
                 }
-                // Load instrument if specified — use load_plugin first (handles native + third-party)
+                // Load instrument if specified — try native OSC first, then load_plugin tool handles fallbacks
                 if (args.instrument) {
-                    const manufacturer = args.manufacturer ? String(args.manufacturer) : '';
-                    if (manufacturer) {
-                        await osc.query('/live/kbot/load_plugin', newTrackIdx, manufacturer, String(args.instrument));
-                    }
-                    else {
-                        // Try load_plugin first (works for native instruments via _deep_plugin_search fallback)
-                        const result = await osc.query('/live/kbot/load_plugin', newTrackIdx, String(args.instrument), '');
-                        const status = extractArgs(result);
-                        if (status[0] !== 'ok') {
-                            // Fallback to load_device
-                            await osc.query('/live/kbot/load_device', newTrackIdx, String(args.instrument));
+                    try {
+                        const loadResult = await osc.query('/live/track/load/device', newTrackIdx, String(args.instrument));
+                        const loadStatus = extractArgs(loadResult);
+                        if (loadStatus.length === 0 || String(loadStatus[0]) === 'error') {
+                            // Native load failed — OSC doesn't have this device. The user can use
+                            // ableton_load_plugin separately which has AppleScript fallback.
                         }
                     }
+                    catch {
+                        // Timeout or connection error — device may still have loaded, continue
+                    }
                 }
                 return `Created ${trackType} track **${args.name || 'Track ' + (newTrackIdx + 1)}**${args.instrument ? ' with ' + args.instrument : ''} (track ${newTrackIdx + 1})`;
             }
@@ -1035,5 +1072,102 @@ export function registerAbletonTools() {
             }
         },
     });
+    // ─── 15. Audio Analysis ──────────────────────────────────────────────
+    registerTool({
+        name: 'ableton_audio_analysis',
+        description: 'Get real-time audio level meters from Ableton Live — track output levels (L/R RMS), master output, and peak detection. Use this to hear what is playing, check if a track has signal, or monitor the mix.',
+        parameters: {
+            track: { type: 'number', description: 'Track number to analyze (1-based). Omit to get master output only.' },
+            all_tracks: { type: 'boolean', description: 'If true, read levels for all tracks plus master. Default: false' },
+        },
+        tier: 'free',
+        timeout: 10_000,
+        async execute(args) {
+            try {
+                const osc = await ensureAbleton();
+                const lines = ['## Audio Levels', ''];
+                // Helper to read a meter value with error handling
+                async function readMeter(address, ...oscArgs) {
+                    try {
+                        const result = await osc.query(address, ...oscArgs);
+                        const vals = extractArgs(result);
+                        // Meter values are typically floats 0.0 - 1.0 (or higher for clipping)
+                        return typeof vals[vals.length - 1] === 'number' ? vals[vals.length - 1] : 0;
+                    }
+                    catch {
+                        return -1; // timeout = no response
+                    }
+                }
+                // Meter bar visualization
+                function meterBar(level) {
+                    if (level < 0)
+                        return '[-no signal-]';
+                    const db = level > 0 ? 20 * Math.log10(level) : -Infinity;
+                    const dbStr = db === -Infinity ? '-inf' : db.toFixed(1);
+                    const barLen = Math.min(20, Math.max(0, Math.round(level * 20)));
+                    const bar = '\u2588'.repeat(barLen) + '\u2591'.repeat(20 - barLen);
+                    return `[${bar}] ${dbStr} dB`;
+                }
+                if (args.all_tracks) {
+                    // Read all track levels
+                    const countResult = await osc.query('/live/song/get/num_tracks');
+                    const numTracks = Number(extractArgs(countResult)[0]) || 0;
+                    for (let t = 0; t < numTracks - 1; t++) { // -1 to skip master return
+                        const nameResult = await osc.query('/live/track/get/name', t);
+                        const name = extractArgs(nameResult)[1] || `Track ${t + 1}`;
+                        const left = await readMeter('/live/track/get/output_meter_left', t);
+                        const right = await readMeter('/live/track/get/output_meter_right', t);
+                        const avg = left >= 0 && right >= 0 ? (left + right) / 2 : Math.max(left, right);
+                        lines.push(`**${displayTrack(t)}. ${name}**: ${meterBar(avg)}`);
+                        if (left >= 0 && right >= 0 && Math.abs(left - right) > 0.05) {
+                            lines.push(`  L: ${meterBar(left)} | R: ${meterBar(right)}`);
+                        }
+                    }
+                    lines.push('');
+                }
+                else if (args.track) {
+                    // Read specific track
+                    const t = userTrack(args.track);
+                    const nameResult = await osc.query('/live/track/get/name', t);
+                    const name = extractArgs(nameResult)[1] || `Track ${args.track}`;
+                    const left = await readMeter('/live/track/get/output_meter_left', t);
+                    const right = await readMeter('/live/track/get/output_meter_right', t);
+                    lines.push(`**Track ${args.track} (${name})**`);
+                    lines.push(`  Left:  ${meterBar(left)}`);
+                    lines.push(`  Right: ${meterBar(right)}`);
+                    // Check if signal is present
+                    const avg = left >= 0 && right >= 0 ? (left + right) / 2 : Math.max(left, right);
+                    if (avg <= 0) {
+                        lines.push('');
+                        lines.push('No signal detected. Check: is the track armed? Is transport playing? Does the track have clips?');
+                    }
+                    else if (avg > 1.0) {
+                        lines.push('');
+                        lines.push('**Warning**: Signal is clipping! Reduce track volume.');
+                    }
+                    lines.push('');
+                }
+                // Always show master output
+                const masterLeft = await readMeter('/live/master/get/output_meter_left');
+                const masterRight = await readMeter('/live/master/get/output_meter_right');
+                lines.push('**Master Output**');
+                lines.push(`  Left:  ${meterBar(masterLeft)}`);
+                lines.push(`  Right: ${meterBar(masterRight)}`);
+                const masterAvg = masterLeft >= 0 && masterRight >= 0 ? (masterLeft + masterRight) / 2 : Math.max(masterLeft, masterRight);
+                if (masterAvg <= 0) {
+                    lines.push('');
+                    lines.push('No audio on master output. Is transport playing?');
+                }
+                else if (masterAvg > 0.9) {
+                    lines.push('');
+                    lines.push('**Loud!** Master is near clipping. Consider reducing levels.');
+                }
+                return lines.join('\n');
+            }
+            catch (err) {
+                return `Ableton connection failed: ${err.message}\n\n${formatAbletonError()}`;
+            }
+        },
+    });
 }
 //# sourceMappingURL=ableton.js.map

package/dist/tools/audit.js

@@ -415,7 +415,7 @@ function formatAuditReport(result) {
     // Badge
     const badgeColor = pct >= 80 ? 'brightgreen' : pct >= 60 ? 'yellow' : 'red';
     const badgeUrl = `https://img.shields.io/badge/kbot_audit-${result.grade}_(${pct}%25)-${badgeColor}`;
-    lines.push('---', '', '### Add this badge to your README', '', '```markdown', `[![kbot audit: ${result.grade}](${badgeUrl})](https://www.npmjs.com/package/@kernel.chat/kbot)`, '```', '', `*Audited by [kbot](https://www.npmjs.com/package/@kernel.chat/kbot) — 35 specialist agents, 686+ tools, 20 AI providers*`, `*Install: \`npm install -g @kernel.chat/kbot\` | Audit any repo: \`kbot audit owner/repo\`*`);
+    lines.push('---', '', '### Add this badge to your README', '', '```markdown', `[![kbot audit: ${result.grade}](${badgeUrl})](https://www.npmjs.com/package/@kernel.chat/kbot)`, '```', '', `*Audited by [kbot](https://www.npmjs.com/package/@kernel.chat/kbot) — 35 specialist agents, 787+ tools, 20 AI providers*`, `*Install: \`npm install -g @kernel.chat/kbot\` | Audit any repo: \`kbot audit owner/repo\`*`);
     return lines.join('\n');
 }
 /** Generate a compact one-line summary for social sharing */
@@ -546,7 +546,7 @@ function formatAuditTerminal(result) {
     // Install CTA
     lines.push(chalk.hex(DIM)('  Audited by ') +
         chalk.hex(VIOLET).bold('kbot') +
-        chalk.hex(DIM)(' \u2014 35 specialist agents, 686+ tools, 20 AI providers'));
+        chalk.hex(DIM)(' \u2014 35 specialist agents, 787+ tools, 20 AI providers'));
     lines.push(chalk.hex(DIM)('  Install: ') +
         chalk.hex(WHITE)('npm install -g @kernel.chat/kbot') +
         chalk.hex(DIM)('  |  Audit any repo: ') +